diff --git a/system/core/CodeIgniter.php b/system/core/CodeIgniter.php
index 6d67471..df5fa3b 100644
--- a/system/core/CodeIgniter.php
+++ b/system/core/CodeIgniter.php
@@ -212,7 +212,7 @@
  *  Instantiate the routing class and set the routing
  * ------------------------------------------------------
  */
-	$RTR =& load_class('Router', 'core');
+	$RTR =& load_class('Router', 'core', isset($routing) ? $routing : NULL);
 
 /*
  * ------------------------------------------------------
@@ -226,8 +226,7 @@
  *	Is there a valid cache file? If so, we're done...
  * ------------------------------------------------------
  */
-	if ($EXT->call_hook('cache_override') === FALSE
-		&& $OUT->_display_cache($CFG, $URI) === TRUE)
+	if ($EXT->call_hook('cache_override') === FALSE && $OUT->_display_cache($CFG, $URI) === TRUE)
 	{
 		exit;
 	}
diff --git a/system/core/Common.php b/system/core/Common.php
index 0ea53c4..24315a0 100644
--- a/system/core/Common.php
+++ b/system/core/Common.php
@@ -130,7 +130,7 @@
 	 * @param	string	the class name prefix
 	 * @return	object
 	 */
-	function &load_class($class, $directory = 'libraries', $prefix = 'CI_')
+	function &load_class($class, $directory = 'libraries', $param = NULL)
 	{
 		static $_classes = array();
 
@@ -148,7 +148,7 @@
 		{
 			if (file_exists($path.$directory.'/'.$class.'.php'))
 			{
-				$name = $prefix.$class;
+				$name = 'CI_'.$class;
 
 				if (class_exists($name, FALSE) === FALSE)
 				{
@@ -166,7 +166,7 @@
 
 			if (class_exists($name, FALSE) === FALSE)
 			{
-				require_once(APPPATH.$directory.'/'.config_item('subclass_prefix').$class.'.php');
+				require_once(APPPATH.$directory.'/'.$name.'.php');
 			}
 		}
 
@@ -183,8 +183,9 @@
 		// Keep track of what we just loaded
 		is_loaded($class);
 
-		$_classes[$class] = new $name();
-		return $_classes[$class];
+		return $_classes[$class] = isset($param)
+			? new $name($param)
+			: new $name();
 	}
 }
 
diff --git a/system/core/Input.php b/system/core/Input.php
index fdb308b..620e50f 100644
--- a/system/core/Input.php
+++ b/system/core/Input.php
@@ -126,14 +126,12 @@
 		$this->_enable_csrf		= (config_item('csrf_protection') === TRUE);
 		$this->_sandardize_newlines	= (bool) config_item('standardize_newlines');
 
-		global $SEC;
-		$this->security =& $SEC;
+		$this->security =& load_class('Security', 'core');
 
 		// Do we need the UTF-8 class?
 		if (UTF8_ENABLED === TRUE)
 		{
-			global $UNI;
-			$this->uni =& $UNI;
+			$this->uni =& load_class('Utf8', 'core');
 		}
 
 		// Sanitize global arrays
diff --git a/system/core/Output.php b/system/core/Output.php
index e8c1c39..2811a73 100644
--- a/system/core/Output.php
+++ b/system/core/Output.php
@@ -401,10 +401,11 @@
 	 */
 	public function _display($output = '')
 	{
-		// Note:  We use globals because we can't use $CI =& get_instance()
+		// Note:  We use load_class() because we can't use $CI =& get_instance()
 		// since this function is sometimes called by the caching mechanism,
 		// which happens before the CI super object is available.
-		global $BM, $CFG;
+		$BM =& load_class('Benchmark', 'core');
+		$CFG =& load_class('Config', 'core');
 
 		// Grab the super object if we can.
 		if (class_exists('CI_Controller', FALSE))
diff --git a/system/core/Router.php b/system/core/Router.php
index 05263b1..2448d9c 100644
--- a/system/core/Router.php
+++ b/system/core/Router.php
@@ -109,10 +109,8 @@
 	 *
 	 * @return	void
 	 */
-	public function __construct()
+	public function __construct($routing = NULL)
 	{
-		global $routing;
-
 		$this->config =& load_class('Config', 'core');
 		$this->uri =& load_class('URI', 'core');
 
@@ -120,7 +118,7 @@
 		$this->_set_routing();
 
 		// Set any routing overrides that may exist in the main index file
-		if (isset($routing) && is_array($routing))
+		if (is_array($routing))
 		{
 			if (isset($routing['directory']))
 			{
diff --git a/system/core/URI.php b/system/core/URI.php
index 5f5a9ce..9a545fd 100644
--- a/system/core/URI.php
+++ b/system/core/URI.php
@@ -628,9 +628,7 @@
 	 */
 	public function ruri_string()
 	{
-		global $RTR;
-
-		return ltrim($RTR->directory, '/').implode('/', $this->rsegments);
+		return ltrim(load_class('Router', 'core')->directory, '/').implode('/', $this->rsegments);
 	}
 
 }
